A Pattern-Based Game Mechanics Design Assistant

Video game designers iteratively improve player experience by play testing game software and adjusting its design. Deciding how to improve gameplay is difficult and time-consuming because designers lack an effective means for exploring decision alternatives and modifying a game’s mechanics. We aim to improve designer productivity and game quality by providing tools that speed-up the game design process. In particular, we wish to learn how patterns encoding common game design knowledge can help to improve design tools. Micro-Machinations (MM) is a language and software library that enables game designers to modify a game’s mechanics at run-time. We propose a pattern-base

Cascade: A meta-language for change, cause and effect

Live programming brings code to life with immediate and continuous feedback. To enjoy its benefits, programmers need powerful languages and live programming environments for understanding the effects of code modifications on running programs. Unfortunately, the enabling technology that powers these languages, is missing. Change, a crucial enabler for explorative coding, omniscient debugging and version control, is a potential solution. We aim to deliver generic solutions for creating these languages, in particular Domain-Specific Languages (DSLs). We present Cascade, a meta-language for expressing DSLs with interface- and feedback-mechanisms that drive live programming. We demonstrate run-time migrations, ripple effects and live desugaring of three existing DSLs. Our results show that an explicit representation of change is instrumental for how these languages are built, and that cause-and-effect relationships are vital for delivering precise feedback

Game engine wizardry for programming mischief

Programming grants individuals the capability to design, create, and bring ideas to life. To improve their skills, programmers require powerful languages and programming environments for understanding the impact of gradual code changes. We investigate how modern game engine technology can be leveraged for creating visual input and feedback mechanisms that drive exploratory and live programming. In this paper, we report experiences on creating a visual programming environment for Machinations, a domain-specific language for game design. We share initial findings on how to automate the development of graph- and tree- based editors in Godot, an open source game engine. Our results show that today’s game engine technology provides a solid foundation for future programming language research

Languages of games and play: A systematic mapping study

Digital games are a powerful means for creating enticing, beautiful, educational, and often highly addictive interactive experiences that impact the lives of billions of players worldwide. We explore what informs the design and construction of good games to learn how to speed-up game development. In particular, we study to what extent languages, notations, patterns, and tools, can offer experts theoretical foundations, systematic techniques, and practical solutions they need to raise their productivity and improve the quality of games and play. Despite the growing number of publications on this topic there is currently no overview describing the state-of-the-art that relates research areas, goals, and applications. As a result, efforts and successes are often one-off, lessons learned go overlooked, language reuse remains minimal, and opportunities for collaboration and synergy are lost. We present a systematic map that identifies relevant publications and gives an overview of research areas and publication venues. In addition, we categorize research perspectives along common objectives, techniques, and approaches, illustrated by summaries of selected languages. Finally, we distill challenges and opportunities for future research and development

Cascade: A meta-language for change, cause and effect

Live programming brings code to life with immediate and continuous feedback. To enjoy its benefits, programmers need powerful languages and live programming environments for understanding the effects of coding actions and developing running programs. Unfortunately, the enabling technology that powers these languages is missing. Change, a crucial enabler for explorative coding, omniscient debugging and version control, is a potential solution. In this position paper, we argue that an explicit representation of change is instrumental for how these languages are built, and that cause-and-effect relationships are vital for more precise feedback. We aim to deliver generic solutions for creating these languages. We introduce Cascade, a meta-language and framework for expressing languages with interface- and feedback-mechanisms that drive live programming. Our preliminary results show that Cascade is a promising approach that simplifies developing language back-ends

Adapting Game Mechanics with Micro-Machinations

In early game development phases game designers adjust game rules in a rapid, iterative and flexible way. In later phases, when software prototypes are available, play testing provides more detailed feedback about player experience. More often than not, the realized and the intended gameplay emerging from game software differ. Unfortunately, adjusting it is hard because designers lack a means for efficiently defining, fine-tuning and balancing game mechanics. The language Machinations provides a graphical notation for expressing the rules of game economies that fits with a designer’s understanding and vocabulary, but is limited to design itself. Micro-Mach

Micro-Machinations: A DSL for Game Economies

In the multi-billion dollar game industry, time to market limits the time developers have for improving games. Game designers and software engineers usually live on opposite sides of the fence, and both lose time when adjustments best understood by designers are implemented by engineers. Designers lack a common vocabulary for expressing gameplay, which hampers specification, communication and agreement. We aim to speed up the game development process by improving designer productivity and design quality. The language Machinations has introduced a graphical notation for expressing the rules of game economies that is close to a designer’s vocabulary. We present the language Micro- Machinations (MM) that details and formalizes the meaning of a significant subset of Machination’s language features and adds sever

Model Differencing for Textual DSLs

The syntactic and semantic comparison of models is important for understanding and supporting their evolution. In this paper we present TMDIFF, a technique for semantically comparing models that are represented as text. TMDIFF incorporates the referential structure of a language, which is determined by symbolic names and language-specific scoping rules. Furthermore, it employs a novel technique for matching entities existing in source and target versions of a model, and finds entities that are added or removed. As a result, TMDIFF is fully language parametric, and brings the benefits of model differencing to textual languages

ScriptButler serves an empirical study of PuzzleScript : Analyzing the expressive power of a game DSL through source code analysis

Automated Game Design (AGD) empowers game designers with languages and tools that automate game design processes. Domain- Specific Languages (DSLs) promise to deliver an expressive means for rapidly prototyping and fine-tuning interaction mechanisms that support rich emergent player experiences. However, despite the growing number of studies that center around languages for games and play, few prototypes are ever thoroughly validated and evaluated in practice. As a result, it is not yet well understood what the costs, benefits and limitations of DSL formalisms are. To find out, we investigate to what extent rules, affordances and play can be related by means of source code analysis. We study PuzzleScript, a language and online game engine with an active user community. We reverse engineer PuzzleScript’s design and propose ScriptButler, a novel tool prototype and engine for its analysis. To validate our approach, we conduct an empirical study on the quality of the source code by performing an analysis on a curated collection of 95 games. Our results show that ScriptButler can identify bugs and helps relate PuzzleScript rules to game qualities